import ttsApi from './ttsApi.js';

export default {
  /**
   * 发送POST请求的异步函数
   * 同步处理长文本（≤140字符/段），生成语音音频，适配多段文本的音频源生成
   * @param {Object} data 包含请求相关数据的对象
   * @returns {Object|Array<Object>} 单段返回对象，多段返回对象数组（含每段音频信息）
   */
  async sendPostRequestApi(data) {
    // 初始化返回数据基础结构
    let returnD = { ...data };
    returnD.audioInit = false;
    returnD.isAudioStart = { id: data.msg_i, is: false };

    // 存储最终要返回的音频段数组（适配多段文本）
    const resultList = [];

    // 处理整体执行模式的文本拆分
    let targetText = data.text;
    if (data.all) {
      if (data.to_i === -1) {
        returnD.audioInit = true;
        data.to_i++;
      }
      // 按指定分隔符拆分原始文本
      const msgArr = data.msg_content.split(data.toSpeechtest);
      targetText = msgArr[data.to_i] || '';
      // 无文本则返回false
      if (!targetText) {
        return false;
      }
    }

    // 文本为空直接返回错误
    if (!targetText?.length) {
      console.error("text无数据", data);
      return false;
    }

    /**
     * 同步处理长文本：拆分超过140字符的文本，优先按逗号拆分（改逗号为句号）
     * @param {string} text 待处理文本
     * @param {number} maxLen 最大长度限制
     * @returns {Array<string>} 拆分后的文本数组
     */
    const splitLongTextSync = (text, maxLen = 140) => {
      const textList = [];
      let currentText = text.trim();

      while (currentText.length > maxLen) {
        // 从140字符位置向前找最近的逗号
        let commaPos = -1;
        const searchEnd = Math.min(maxLen, currentText.length);
        // 最多向前回溯20个字符，平衡语义和效率
        const searchStart = Math.max(0, searchEnd - 20);

        for (let i = searchEnd; i >= searchStart; i--) {
          if (currentText[i] === '，') {
            commaPos = i;
            break;
          }
        }

        if (commaPos !== -1) {
          // 找到逗号：改逗号为句号，截取前半段
          const part = currentText.substring(0, commaPos) + '。';
          textList.push(part);
          // 剩余文本继续处理
          currentText = currentText.substring(commaPos + 1).trim();
        } else {
          // 无逗号：直接按长度截断
          textList.push(currentText.substring(0, maxLen));
          currentText = currentText.substring(maxLen).trim();
        }
      }

      // 添加最后一段文本
      if (currentText) {
        textList.push(currentText);
      }
      return textList;
    };

    // 同步拆分长文本
    const processedTextList = splitLongTextSync(targetText);

    // 遍历拆分后的文本，逐个生成音频（同步处理，顺序保证）
    for (let index = 0; index < processedTextList.length; index++) {
      const currentText = processedTextList[index];
      // 复制基础返回结构，避免段间数据污染
      const segmentReturn = { ...returnD };
      const segmentToI = data.to_i + index; // 计算当前段的真实下标（适配多段）

      // 处理文本特殊字符
      let modifiedText = currentText
        .replace(/\*/g, ',')
        .replace(/\|/g, ',')
        .replace(/-/g, ',')
        .replace(/\s+/g, ' ')
        .replace(/ {2,}/g, ', ');

      // 生成当前段的音频源信息
      const toSArr = {
        id: segmentToI,
        src: '',
        text: currentText
      };
      segmentReturn.audioSrc = toSArr;
      segmentReturn.to_i = segmentToI; // 更新当前段下标

      try {
        // 调用语音合成接口获取Base64音频数据
        // 整理本地的设置参数
        const tts_data = {
          text: modifiedText,
          speed: localStorage.getItem('tts_speed'),
        };
        const dataArr = await ttsApi.textToVoice(tts_data);
        const audioBase64 = dataArr.data;

        // Base64转Blob生成音频URL
        const byteCharacters = atob(audioBase64);
        const byteNumbers = new Array(byteCharacters.length);
        for (let i = 0; i < byteCharacters.length; i++) {
          byteNumbers[i] = byteCharacters.charCodeAt(i);
        }
        const byteArray = new Uint8Array(byteNumbers);
        const audioBlob = new Blob([byteArray], { type: 'audio/wav' });
        const blobSrc = URL.createObjectURL(audioBlob);

        // 赋值音频源
        segmentReturn.audioSrc.src = blobSrc;

        // 处理首段音频的播放状态
        if (segmentToI === 0 && !this.audioAutoKey && !this.isAutoAudio) {
          segmentReturn.isAudioStart.is = true;
          segmentReturn.audioStart = true;
        }
      } catch (error) {
        console.error(`第${segmentToI}段音频生成失败`, error);
        segmentReturn.audioSrc.src = ''; // 标记失败状态
      }

      resultList.push(segmentReturn);
    }

    // 单段返回对象，多段返回数组（方便调用方处理）
    return resultList.length === 1 ? resultList[0] : resultList;
  }
};